{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"Copy of Magic Wand Training","provenance":[{"file_id":"https://github.com/petewarden/magic_wand/blob/main/train/train_magic_wand_model.ipynb","timestamp":1638386707719}],"collapsed_sections":[]},"kernelspec":{"name":"python3","display_name":"Python 3"}},"cells":[{"cell_type":"code","metadata":{"id":"0g1pF6RfViPr","executionInfo":{"status":"ok","timestamp":1638745473565,"user_tz":480,"elapsed":179,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}}},"source":["SAVED_MODEL_FILENAME = \"saved_model\"\n","FLOAT_TFL_MODEL_FILENAME = \"float_model.tfl\"\n","QUANTIZED_TFL_MODEL_FILENAME = \"quantized_model.tfl\"\n","TFL_CC_MODEL_FILENAME = \"magic_wand_model_data.cc\""],"execution_count":1,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"xvPo0OP0TFDq","executionInfo":{"status":"ok","timestamp":1638745477856,"user_tz":480,"elapsed":2072,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"2b44a027-1c9a-46aa-9660-57db546c8f75"},"source":["!curl -L https://github.com/petewarden/magic_wand_digit_data/archive/8170591863f9addca27b1a963263f7c7bed33f41.zip -o magic_wand_digit_data.zip\n","!unzip magic_wand_digit_data.zip\n","!rm -rf magic_wand_digit_data\n","!mv magic_wand_digit_data-* magic_wand_digit_data\n","!rm -rf magic_wand_digit_data.zip\n","!rm -rf sample_data\n","!mkdir -p checkpoints"],"execution_count":2,"outputs":[{"output_type":"stream","name":"stdout","text":["  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n","                                 Dload  Upload   Total   Spent    Left  Speed\n","100   171    0   171    0     0    228      0 --:--:-- --:--:-- --:--:--   228\n","100  238k    0  238k    0     0   250k      0 --:--:-- --:--:-- --:--:-- 1667k\n","Archive:  magic_wand_digit_data.zip\n","8170591863f9addca27b1a963263f7c7bed33f41\n","   creating: magic_wand_digit_data-8170591863f9addca27b1a963263f7c7bed33f41/\n","  inflating: magic_wand_digit_data-8170591863f9addca27b1a963263f7c7bed33f41/LICENSE  \n","  inflating: magic_wand_digit_data-8170591863f9addca27b1a963263f7c7bed33f41/petewarden_0.json  \n","  inflating: magic_wand_digit_data-8170591863f9addca27b1a963263f7c7bed33f41/petewarden_1.json  \n","  inflating: magic_wand_digit_data-8170591863f9addca27b1a963263f7c7bed33f41/petewarden_2.json  \n","  inflating: magic_wand_digit_data-8170591863f9addca27b1a963263f7c7bed33f41/petewarden_3.json  \n","  inflating: magic_wand_digit_data-8170591863f9addca27b1a963263f7c7bed33f41/petewarden_4.json  \n","  inflating: magic_wand_digit_data-8170591863f9addca27b1a963263f7c7bed33f41/petewarden_5.json  \n","  inflating: magic_wand_digit_data-8170591863f9addca27b1a963263f7c7bed33f41/petewarden_6.json  \n","  inflating: magic_wand_digit_data-8170591863f9addca27b1a963263f7c7bed33f41/petewarden_7.json  \n","  inflating: magic_wand_digit_data-8170591863f9addca27b1a963263f7c7bed33f41/petewarden_8.json  \n","  inflating: magic_wand_digit_data-8170591863f9addca27b1a963263f7c7bed33f41/petewarden_9.json  \n"]}]},{"cell_type":"code","metadata":{"id":"mWO58-igVFSd","executionInfo":{"status":"ok","timestamp":1638745496968,"user_tz":480,"elapsed":166,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}}},"source":["import glob\n","import json\n","\n","strokes = []\n","for filename in glob.glob(\"magic_wand_digit_data/*.json\"):\n","  with open(filename, \"r\") as file:\n","    file_contents = file.read()\n","  file_data = json.loads(file_contents)\n","  for stroke in file_data[\"strokes\"]:\n","    stroke[\"filename\"] = filename\n","    strokes.append(stroke)"],"execution_count":3,"outputs":[]},{"cell_type":"code","metadata":{"id":"xfLzrpyLVJ5S","executionInfo":{"status":"ok","timestamp":1638745501162,"user_tz":480,"elapsed":171,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}}},"source":["import matplotlib.pyplot as plt\n","\n","def plot_stroke(stroke):\n","\n","  x_array = []\n","  y_array = []\n","  for coords in stroke[\"strokePoints\"]:\n","    x_array.append(coords[\"x\"])\n","    y_array.append(coords[\"y\"])\n","\n","  fig = plt.figure(figsize=(12.8, 4.8))\n","  fig.suptitle(stroke[\"label\"])\n","\n","  ax = fig.add_subplot(131)\n","  ax.set_xlabel('x')\n","  ax.set_ylabel('y')\n","  ax.set_xlim(-0.4, 0.4)\n","  ax.set_ylim(-0.4, 0.4)\n","  ax.plot(x_array, y_array)\n","\n","  plt.show()"],"execution_count":4,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":391},"id":"dveZd2ZuW-jl","executionInfo":{"status":"ok","timestamp":1638746177871,"user_tz":480,"elapsed":466,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"ab8d5f8e-d753-49eb-fc06-607944f55e86"},"source":["import numpy as np\n","\n","shuffled_strokes = list(strokes)\n","np.random.shuffle(shuffled_strokes)\n","plot_stroke(shuffled_strokes[0])\n","print(f\"This stroke: {len(shuffled_strokes[0]['strokePoints'])}\")\n","func = lambda x: len(x[\"strokePoints\"])\n","values = list(map(func, strokes))\n","print(f\"All strokes: min {np.min(values)} max {np.max(values)} avg {np.average(values)}\")"],"execution_count":8,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 921.6x345.6 with 1 Axes>"]},"metadata":{"needs_background":"light"}},{"output_type":"stream","name":"stdout","text":["This stroke: 89\n","All strokes: min 32 max 145 avg 94.526\n"]}]},{"cell_type":"code","metadata":{"id":"3FVPj-eqjvoB","executionInfo":{"status":"ok","timestamp":1638746658017,"user_tz":480,"elapsed":192,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}}},"source":["import math\n","import numpy as np\n","import PIL\n","\n","FIXED_POINT = 4096\n","\n","def mul_fp(a, b):\n","  return (a * b) // FIXED_POINT\n","\n","def div_fp(a, b):\n","  if b == 0:\n","    b = 1\n","  return (a * FIXED_POINT) // b\n","\n","def float_to_fp(a):\n","  return math.floor(a * FIXED_POINT)\n","\n","def norm_to_coord_fp(a, range_fp, half_size_fp):\n","  a_fp = float_to_fp(a)\n","  norm_fp = div_fp(a_fp, range_fp)\n","  return mul_fp(norm_fp, half_size_fp) + half_size_fp\n","\n","def round_fp_to_int(a):\n","  return math.floor((a + (FIXED_POINT / 2)) / FIXED_POINT)\n","\n","def gate(a, min, max):\n","  if a < min:\n","    return min\n","  elif a > max:\n","    return max\n","  else:\n","    return a\n","\n","def rasterize_stroke(stroke_points, x_range, y_range, width, height):\n","  num_channels = 3\n","  buffer_byte_count = height * width * num_channels\n","  buffer = bytearray(buffer_byte_count)\n","\n","  width_fp = width * FIXED_POINT\n","  height_fp = height * FIXED_POINT\n","  half_width_fp = width_fp / 2\n","  half_height_fp = height_fp / 2\n","  x_range_fp = float_to_fp(x_range)\n","  y_range_fp = float_to_fp(y_range)\n","\n","  t_inc_fp = FIXED_POINT // len(stroke_points)\n","\n","  one_half_fp = (FIXED_POINT / 2)\n","\n","  for point_index in range(len(stroke_points) - 1):\n","    start_point = stroke_points[point_index]\n","    end_point = stroke_points[point_index + 1]\n","    start_x_fp = norm_to_coord_fp(start_point[\"x\"], x_range_fp, half_width_fp)\n","    start_y_fp = norm_to_coord_fp(-start_point[\"y\"], y_range_fp, half_height_fp)\n","    end_x_fp = norm_to_coord_fp(end_point[\"x\"], x_range_fp, half_width_fp)\n","    end_y_fp = norm_to_coord_fp(-end_point[\"y\"], y_range_fp, half_height_fp)\n","    delta_x_fp = end_x_fp - start_x_fp\n","    delta_y_fp = end_y_fp - start_y_fp\n","\n","    t_fp = point_index * t_inc_fp\n","    if t_fp < one_half_fp:\n","      local_t_fp = div_fp(t_fp, one_half_fp)\n","      one_minus_t_fp = FIXED_POINT - local_t_fp\n","      red = round_fp_to_int(one_minus_t_fp * 255)\n","      green = round_fp_to_int(local_t_fp * 255)\n","      blue = 0\n","    else:\n","      local_t_fp = div_fp(t_fp - one_half_fp, one_half_fp)\n","      one_minus_t_fp = FIXED_POINT - local_t_fp\n","      red = 0\n","      green = round_fp_to_int(one_minus_t_fp * 255)\n","      blue = round_fp_to_int(local_t_fp * 255)\n","    red = gate(red, 0, 255)\n","    green = gate(green, 0, 255)\n","    blue = gate(blue, 0, 255)\n","\n","    if abs(delta_x_fp) > abs(delta_y_fp):\n","      line_length = abs(round_fp_to_int(delta_x_fp))\n","      if delta_x_fp > 0:\n","        x_inc_fp = 1 * FIXED_POINT\n","        y_inc_fp = div_fp(delta_y_fp, delta_x_fp)\n","      else:\n","        x_inc_fp = -1 * FIXED_POINT\n","        y_inc_fp = -div_fp(delta_y_fp, delta_x_fp)\n","    else:\n","      line_length = abs(round_fp_to_int(delta_y_fp))\n","      if delta_y_fp > 0:\n","        y_inc_fp = 1 * FIXED_POINT\n","        x_inc_fp = div_fp(delta_x_fp, delta_y_fp)\n","      else:\n","        y_inc_fp = -1 * FIXED_POINT\n","        x_inc_fp = -div_fp(delta_x_fp, delta_y_fp)\n","    for i in range(line_length + 1):\n","      x_fp = start_x_fp + (i * x_inc_fp)\n","      y_fp = start_y_fp + (i * y_inc_fp)\n","      x = round_fp_to_int(x_fp)\n","      y = round_fp_to_int(y_fp)\n","      if (x < 0) or (x >= width) or (y < 0) or (y >= height):\n","        continue\n","      buffer_index = (y * width * num_channels) + (x * num_channels)\n","      buffer[buffer_index + 0] = red\n","      buffer[buffer_index + 1] = green\n","      buffer[buffer_index + 2] = blue\n","  \n","  np_buffer = np.frombuffer(buffer, dtype=np.uint8).reshape(height, width, num_channels)\n","\n","  return np_buffer"],"execution_count":9,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":529},"id":"sOaxOIjRskJg","executionInfo":{"status":"ok","timestamp":1638746717413,"user_tz":480,"elapsed":165,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"9f3e55ad-2c1e-4441-cdc8-fabc272e3b50"},"source":["raster = rasterize_stroke(shuffled_strokes[0][\"strokePoints\"], 0.5, 0.5, 32, 32)\n","img = PIL.Image.fromarray(raster).resize((512, 512), PIL.Image.NEAREST)\n","display(img)"],"execution_count":10,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<PIL.Image.Image image mode=RGB size=512x512 at 0x7FDB01E43490>"]},"metadata":{}}]},{"cell_type":"code","metadata":{"id":"o-FOVdFpgkdf","executionInfo":{"status":"ok","timestamp":1638746921132,"user_tz":480,"elapsed":150,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}}},"source":["from pathlib import Path\n","import shutil\n","\n","X_RANGE = 0.6\n","Y_RANGE = 0.6\n","\n","def ensure_empty_dir(dirname):\n","  dirpath = Path(dirname)\n","  if dirpath.exists() and dirpath.is_dir():\n","    shutil.rmtree(dirpath)\n","  dirpath.mkdir()\n","\n","def augment_points(points, move_range, scale_range, rotate_range):\n","  move_x = np.random.uniform(low=-move_range, high=move_range)\n","  move_y = np.random.uniform(low=-move_range, high=move_range)\n","  scale = np.random.uniform(low=1.0-scale_range, high=1.0+scale_range)\n","  rotate = np.random.uniform(low=-rotate_range, high=rotate_range)\n","\n","  x_axis_x = math.cos(rotate) * scale\n","  x_axis_y = math.sin(rotate) * scale\n","\n","  y_axis_x = -math.sin(rotate) * scale\n","  y_axis_y = math.cos(rotate) * scale\n","\n","  new_points = []\n","  for point in points:\n","    old_x = point[\"x\"]\n","    old_y = point[\"y\"]\n","    new_x = (x_axis_x * old_x) + (x_axis_y * old_y) + move_x\n","    new_y = (y_axis_x * old_x) + (y_axis_y * old_y) + move_y\n","    new_points.append({\"x\": new_x, \"y\": new_y})\n","\n","  return new_points\n","\n","def save_strokes_as_images(strokes, root_folder, width, height, augment_count):\n","  ensure_empty_dir(root_folder)\n","  labels = set()\n","  for stroke in strokes:\n","    labels.add(stroke[\"label\"].lower())\n","  for label in labels:\n","    label_path = Path(root_folder, label)\n","    ensure_empty_dir(label_path)\n","\n","  label_counts = {}\n","  for stroke in strokes:\n","    points = stroke[\"strokePoints\"]\n","    label = stroke[\"label\"].lower()\n","    if label == \"\":\n","      raise Exception(\"Missing label for %s:%d\" % (stroke[\"filename\"], stroke[\"index\"]))\n","    if label not in label_counts:\n","      label_counts[label] = 0\n","    label_count = label_counts[label]\n","    label_counts[label] += 1\n","    raster = rasterize_stroke(points, X_RANGE, Y_RANGE, width, height)\n","    image = PIL.Image.fromarray(raster)\n","    image.save(Path(root_folder, label, str(label_count) + \".png\"))\n","    for i in range(augment_count):\n","      # Note: no move augmentation as the stroke should be more or less\n","      # centered within the raster\n","      augmented_points = augment_points(points, 0.0, 0.1, 0.3)\n","      raster = rasterize_stroke(augmented_points, X_RANGE, Y_RANGE, width, height)\n","      image = PIL.Image.fromarray(raster)\n","      image.save(Path(root_folder, label, str(label_count) + \"_a\" + str(i) + \".png\"))\n"],"execution_count":11,"outputs":[]},{"cell_type":"code","metadata":{"id":"2cmmhBwW9d_p","executionInfo":{"status":"ok","timestamp":1638747505532,"user_tz":480,"elapsed":13446,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}}},"source":["IMAGE_WIDTH = 32\n","IMAGE_HEIGHT = 32\n","\n","shuffled_strokes = list(strokes)\n","np.random.shuffle(shuffled_strokes)\n","\n","test_percentage = 10\n","validation_percentage = 10\n","train_percentage = 100 - (test_percentage + validation_percentage)\n","\n","test_count = math.floor((len(shuffled_strokes) * test_percentage) / 100)\n","validation_count = math.floor((len(shuffled_strokes) * validation_percentage) / 100)\n","test_strokes = shuffled_strokes[0:test_count]\n","validation_strokes = shuffled_strokes[test_count:(test_count + validation_count)]\n","train_strokes = shuffled_strokes[(test_count + validation_count):]\n","\n","save_strokes_as_images(test_strokes, \"test\", IMAGE_WIDTH, IMAGE_HEIGHT, 10)\n","save_strokes_as_images(validation_strokes, \"validation\", IMAGE_WIDTH, IMAGE_HEIGHT, 0)\n","save_strokes_as_images(train_strokes, \"train\", IMAGE_WIDTH, IMAGE_HEIGHT, 10)"],"execution_count":12,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"9-Ttfz7LlPil","executionInfo":{"status":"ok","timestamp":1638747530290,"user_tz":480,"elapsed":3475,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"2e9daa0f-acea-4c5e-c4c3-89a7060f388a"},"source":["\n","import tensorflow as tf\n","from tensorflow import keras\n","from tensorflow.keras.utils import image_dataset_from_directory\n","\n","validation_ds = image_dataset_from_directory(\n","    directory='validation',\n","    labels='inferred',\n","    label_mode='categorical',\n","    batch_size=32,\n","    image_size=(IMAGE_WIDTH, IMAGE_HEIGHT)).prefetch(buffer_size=32)\n","\n","train_ds = image_dataset_from_directory(\n","    directory='train',\n","    labels='inferred',\n","    label_mode='categorical',\n","    batch_size=32,\n","    image_size=(IMAGE_WIDTH, IMAGE_HEIGHT)).prefetch(buffer_size=32)\n"],"execution_count":13,"outputs":[{"output_type":"stream","name":"stdout","text":["Found 100 files belonging to 10 classes.\n","Found 8800 files belonging to 10 classes.\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":591},"id":"Q_vUMVmQn400","executionInfo":{"status":"ok","timestamp":1638747597760,"user_tz":480,"elapsed":1017,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"07159ba4-ee1b-4364-8776-3726db2e0595"},"source":["import matplotlib.pyplot as plt\n","\n","plt.figure(figsize=(10, 10))\n","for images, labels in train_ds.take(1):\n","  for i in range(9):\n","    ax = plt.subplot(3, 3, i + 1)\n","    ax.set_title(f\"{np.argmax(labels[i])}\")\n","    plt.imshow(images[i].numpy().astype(\"uint8\"))\n","    plt.axis(\"off\")"],"execution_count":15,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 720x720 with 9 Axes>"]},"metadata":{"needs_background":"light"}}]},{"cell_type":"code","metadata":{"id":"21qi3bLAo80t","executionInfo":{"status":"ok","timestamp":1638747856480,"user_tz":480,"elapsed":184,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}}},"source":["from keras import layers\n","\n","def make_model(input_shape, num_classes):\n","    inputs = keras.Input(shape=input_shape)\n","\n","    # Entry block\n","    x = layers.Rescaling(1.0 / 255)(inputs)\n","    x = layers.Conv2D(16, 3, strides=2, padding=\"same\")(x)\n","    x = layers.BatchNormalization()(x)\n","    x = layers.Activation(\"relu\")(x)\n","    x = layers.Dropout(0.5)(x)\n","\n","    x = layers.Conv2D(32, 3, strides=2, padding=\"same\")(x)\n","    x = layers.BatchNormalization()(x)\n","    x = layers.Activation(\"relu\")(x)\n","    x = layers.Dropout(0.5)(x)\n","\n","    x = layers.Conv2D(64, 3, strides=2, padding=\"same\")(x)\n","    x = layers.BatchNormalization()(x)\n","    x = layers.Activation(\"relu\")(x)\n","    x = layers.Dropout(0.5)(x)\n","\n","    x = layers.GlobalAveragePooling2D()(x)\n","    activation = \"softmax\"\n","    units = num_classes\n","\n","    x = layers.Dropout(0.5)(x)\n","    outputs = layers.Dense(units, activation=activation)(x)\n","    return keras.Model(inputs, outputs)"],"execution_count":16,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"7DjpCkt0qZiy","executionInfo":{"status":"ok","timestamp":1638747862714,"user_tz":480,"elapsed":822,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"eb7158b8-b866-455f-e5fb-7dee1fa25e70"},"source":["model = make_model(input_shape=(IMAGE_WIDTH, IMAGE_HEIGHT, 3), num_classes=10)\n","keras.utils.plot_model(model, show_shapes=True)"],"execution_count":17,"outputs":[{"output_type":"execute_result","data":{"image/png":"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\n","text/plain":["<IPython.core.display.Image object>"]},"metadata":{},"execution_count":17}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"287Am2coqkQC","executionInfo":{"status":"ok","timestamp":1638748150465,"user_tz":480,"elapsed":277815,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"85c947d2-d4d2-47ea-c278-5487002ddf45"},"source":["epochs = 30\n","\n","callbacks = [\n","    keras.callbacks.ModelCheckpoint(\"checkpoints/save_at_{epoch}.h5\"),\n","]\n","model.compile(\n","    optimizer=keras.optimizers.Adam(1e-3),\n","    loss=\"binary_crossentropy\",\n","    metrics=[\"accuracy\"],\n",")\n","model.fit(\n","    train_ds, epochs=epochs, callbacks=callbacks, validation_data=validation_ds,\n",")"],"execution_count":18,"outputs":[{"output_type":"stream","name":"stdout","text":["Epoch 1/30\n","275/275 [==============================] - 9s 29ms/step - loss: 0.3763 - accuracy: 0.1932 - val_loss: 0.3480 - val_accuracy: 0.0800\n","Epoch 2/30\n","275/275 [==============================] - 8s 28ms/step - loss: 0.2665 - accuracy: 0.4103 - val_loss: 0.2391 - val_accuracy: 0.5800\n","Epoch 3/30\n","275/275 [==============================] - 8s 27ms/step - loss: 0.2268 - accuracy: 0.5433 - val_loss: 0.1719 - val_accuracy: 0.8400\n","Epoch 4/30\n","275/275 [==============================] - 7s 27ms/step - loss: 0.1998 - accuracy: 0.6261 - val_loss: 0.1379 - val_accuracy: 0.9000\n","Epoch 5/30\n","275/275 [==============================] - 7s 27ms/step - loss: 0.1794 - accuracy: 0.6794 - val_loss: 0.1251 - val_accuracy: 0.9300\n","Epoch 6/30\n","275/275 [==============================] - 8s 27ms/step - loss: 0.1657 - accuracy: 0.7163 - val_loss: 0.1016 - val_accuracy: 0.9200\n","Epoch 7/30\n","275/275 [==============================] - 7s 27ms/step - loss: 0.1532 - accuracy: 0.7484 - val_loss: 0.0936 - val_accuracy: 0.9600\n","Epoch 8/30\n","275/275 [==============================] - 8s 27ms/step - loss: 0.1436 - accuracy: 0.7665 - val_loss: 0.0766 - val_accuracy: 0.9700\n","Epoch 9/30\n","275/275 [==============================] - 8s 29ms/step - loss: 0.1361 - accuracy: 0.7812 - val_loss: 0.0657 - val_accuracy: 0.9800\n","Epoch 10/30\n","275/275 [==============================] - 9s 32ms/step - loss: 0.1270 - accuracy: 0.8081 - val_loss: 0.0548 - val_accuracy: 0.9700\n","Epoch 11/30\n","275/275 [==============================] - 8s 30ms/step - loss: 0.1230 - accuracy: 0.8209 - val_loss: 0.0554 - val_accuracy: 0.9900\n","Epoch 12/30\n","275/275 [==============================] - 8s 29ms/step - loss: 0.1163 - accuracy: 0.8323 - val_loss: 0.0468 - val_accuracy: 0.9700\n","Epoch 13/30\n","275/275 [==============================] - 8s 30ms/step - loss: 0.1110 - accuracy: 0.8399 - val_loss: 0.0465 - val_accuracy: 0.9900\n","Epoch 14/30\n","275/275 [==============================] - 8s 29ms/step - loss: 0.1089 - accuracy: 0.8405 - val_loss: 0.0511 - val_accuracy: 0.9800\n","Epoch 15/30\n","275/275 [==============================] - 8s 29ms/step - loss: 0.1047 - accuracy: 0.8505 - val_loss: 0.0376 - val_accuracy: 0.9800\n","Epoch 16/30\n","275/275 [==============================] - 8s 28ms/step - loss: 0.1047 - accuracy: 0.8523 - val_loss: 0.0360 - val_accuracy: 0.9800\n","Epoch 17/30\n","275/275 [==============================] - 8s 29ms/step - loss: 0.0993 - accuracy: 0.8637 - val_loss: 0.0337 - val_accuracy: 0.9800\n","Epoch 18/30\n","275/275 [==============================] - 8s 30ms/step - loss: 0.0972 - accuracy: 0.8669 - val_loss: 0.0301 - val_accuracy: 0.9900\n","Epoch 19/30\n","275/275 [==============================] - 8s 28ms/step - loss: 0.0963 - accuracy: 0.8686 - val_loss: 0.0334 - val_accuracy: 0.9800\n","Epoch 20/30\n","275/275 [==============================] - 8s 29ms/step - loss: 0.0929 - accuracy: 0.8790 - val_loss: 0.0333 - val_accuracy: 0.9800\n","Epoch 21/30\n","275/275 [==============================] - 9s 31ms/step - loss: 0.0913 - accuracy: 0.8805 - val_loss: 0.0323 - val_accuracy: 0.9700\n","Epoch 22/30\n","275/275 [==============================] - 9s 30ms/step - loss: 0.0912 - accuracy: 0.8773 - val_loss: 0.0335 - val_accuracy: 0.9800\n","Epoch 23/30\n","275/275 [==============================] - 8s 30ms/step - loss: 0.0863 - accuracy: 0.8865 - val_loss: 0.0326 - val_accuracy: 0.9800\n","Epoch 24/30\n","275/275 [==============================] - 8s 28ms/step - loss: 0.0850 - accuracy: 0.8884 - val_loss: 0.0216 - val_accuracy: 0.9900\n","Epoch 25/30\n","275/275 [==============================] - 8s 28ms/step - loss: 0.0842 - accuracy: 0.8940 - val_loss: 0.0212 - val_accuracy: 0.9800\n","Epoch 26/30\n","275/275 [==============================] - 8s 27ms/step - loss: 0.0835 - accuracy: 0.8914 - val_loss: 0.0194 - val_accuracy: 0.9900\n","Epoch 27/30\n","275/275 [==============================] - 8s 28ms/step - loss: 0.0818 - accuracy: 0.8917 - val_loss: 0.0214 - val_accuracy: 0.9700\n","Epoch 28/30\n","275/275 [==============================] - 8s 28ms/step - loss: 0.0811 - accuracy: 0.8917 - val_loss: 0.0214 - val_accuracy: 0.9700\n","Epoch 29/30\n","275/275 [==============================] - 8s 28ms/step - loss: 0.0794 - accuracy: 0.8950 - val_loss: 0.0201 - val_accuracy: 0.9800\n","Epoch 30/30\n","275/275 [==============================] - 8s 28ms/step - loss: 0.0790 - accuracy: 0.8947 - val_loss: 0.0267 - val_accuracy: 0.9700\n"]},{"output_type":"execute_result","data":{"text/plain":["<keras.callbacks.History at 0x7fda8927ced0>"]},"metadata":{},"execution_count":18}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"ocE3kudZq24U","executionInfo":{"status":"ok","timestamp":1638748338964,"user_tz":480,"elapsed":367,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"cc43a234-3bd4-460d-ef82-806889fc9d38"},"source":["def predict_image(model, filename):\n","  img = keras.preprocessing.image.load_img(filename, target_size=(IMAGE_WIDTH, IMAGE_HEIGHT))\n","  img_array = keras.preprocessing.image.img_to_array(img)\n","  img_array = tf.expand_dims(img_array, 0)  # Create batch axis\n","  predictions = model.predict(img_array).flatten()\n","  predicted_label_index = np.argmax(predictions)\n","  predicted_score = predictions[predicted_label_index]\n","  return (predicted_label_index, predicted_score)\n","  \n","index, score = predict_image(model, \"test/7/2.png\")\n","\n","print(index, score)\n"],"execution_count":19,"outputs":[{"output_type":"stream","name":"stdout","text":["7 0.9931043\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":83},"id":"MYyLaqOYtxTH","executionInfo":{"status":"ok","timestamp":1638748404260,"user_tz":480,"elapsed":54380,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"8c6b1cfc-e51a-461b-d8d6-4064a7f30e61"},"source":["from IPython.display import Image, display\n","\n","SCORE_THRESHOLD = 0.75\n","\n","correct_count = 0\n","wrong_count = 0\n","discarded_count = 0\n","for label_dir in glob.glob(\"test/*\"):\n","  label = int(label_dir.replace(\"test/\", \"\"))\n","  for filename in glob.glob(label_dir + \"/*.png\"):\n","    index, score = predict_image(model, filename)\n","    if score < SCORE_THRESHOLD:\n","      discarded_count += 1\n","      continue\n","    if index == label:\n","      correct_count += 1\n","    else:\n","      wrong_count += 1\n","      print(\"%d expected, %d found with score %f\" % (label, index, score))\n","      display(Image(filename=filename))\n","\n","correct_percentage = (correct_count / (correct_count + wrong_count)) * 100\n","print(\"%.1f%% correct (N=%d, %d unknown)\" % (correct_percentage, (correct_count + wrong_count), discarded_count))"],"execution_count":20,"outputs":[{"output_type":"stream","name":"stdout","text":["9 expected, 7 found with score 0.807747\n"]},{"output_type":"display_data","data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAA8ElEQVR4nGNgGAWjYBTQHDCSocfoLMMvNoav3AxfeBheixFQzEKS0f4bGN4LMvz6xXDOGCrC+Y3hOxc+LUwkWfCblYHtF8MJS4TILzYCWkiwIH0GA/dXhj2uKIJ/f3MQbwJhkDgPlf+dg+EjH34tpAURzxdU/jshBv5P+LWQnIoq2hmE3jGIv2SIb5di+MXGoPiAVBOIBjfViFFFWhChmP6blUy9RIET5kQqJM4HKrdRuIdsGdh+UdUCtl8MvEip5Rcbg9F5Ii0grqiIWMHA+puhkoGBgYFhgz+Dy0YiTScRTM5hWBpFG6NHwSgYBRQBAJY6MnCXjHpLAAAAAElFTkSuQmCC\n","text/plain":["<IPython.core.display.Image object>"]},"metadata":{}},{"output_type":"stream","name":"stdout","text":["99.9% correct (N=1027, 73 unknown)\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"d26wGJn0t20g","executionInfo":{"status":"ok","timestamp":1638748436167,"user_tz":480,"elapsed":2605,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"5d525abe-97bc-4a71-c757-79d8db945d4f"},"source":["model.save(SAVED_MODEL_FILENAME)"],"execution_count":21,"outputs":[{"output_type":"stream","name":"stdout","text":["INFO:tensorflow:Assets written to: saved_model/assets\n"]}]},{"cell_type":"code","metadata":{"id":"ki3E7lM_Kr0C"},"source":["#!curl -L https://storage.googleapis.com/download.tensorflow.org/models/tflite/micro/magic_wand_saved_model_2021_01_02.tgz -o saved_model.tgz\n","#!tar -xzf saved_model.tgz"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"t-hU8aU24gbL","executionInfo":{"status":"ok","timestamp":1638748457118,"user_tz":480,"elapsed":3003,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"8b57dc82-3d72-4bd1-988b-b3a8b85cb101"},"source":["converter = tf.lite.TFLiteConverter.from_saved_model(SAVED_MODEL_FILENAME)\n","model_no_quant_tflite = converter.convert()\n","\n","# Save the model to disk\n","open(FLOAT_TFL_MODEL_FILENAME, \"wb\").write(model_no_quant_tflite)\n","\n","def representative_dataset():\n","  for filename in glob.glob(\"test/*/*.png\"):\n","    img = keras.preprocessing.image.load_img(filename, target_size=(IMAGE_WIDTH, IMAGE_HEIGHT))\n","    img_array = keras.preprocessing.image.img_to_array(img)\n","    img_array = tf.expand_dims(img_array, 0)  # Create batch axis      for images, labels in train_ds.take(1):\n","    yield([img_array])\n","# Set the optimization flag.\n","converter.optimizations = [tf.lite.Optimize.DEFAULT]\n","# Enforce integer only quantization\n","converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]\n","converter.inference_input_type = tf.int8\n","converter.inference_output_type = tf.int8\n","# Provide a representative dataset to ensure we quantize correctly.\n","converter.representative_dataset = representative_dataset\n","model_tflite = converter.convert()\n","\n","# Save the model to disk\n","open(QUANTIZED_TFL_MODEL_FILENAME, \"wb\").write(model_tflite)"],"execution_count":22,"outputs":[{"output_type":"stream","name":"stderr","text":["WARNING:absl:Buffer deduplication procedure will be skipped when flatbuffer library is not properly loaded\n","WARNING:absl:Buffer deduplication procedure will be skipped when flatbuffer library is not properly loaded\n"]},{"output_type":"execute_result","data":{"text/plain":["30880"]},"metadata":{},"execution_count":22}]},{"cell_type":"code","metadata":{"id":"w5QZTfwRLFAi","executionInfo":{"status":"ok","timestamp":1638748759830,"user_tz":480,"elapsed":192,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}}},"source":["def predict_tflite(tflite_model, filename):\n","  img = keras.preprocessing.image.load_img(filename, target_size=(IMAGE_WIDTH, IMAGE_HEIGHT))\n","  img_array = keras.preprocessing.image.img_to_array(img)\n","  img_array = tf.expand_dims(img_array, 0)\n","\n","  # Initialize the TFLite interpreter\n","  interpreter = tf.lite.Interpreter(model_content=tflite_model)\n","  interpreter.allocate_tensors()\n","\n","  input_details = interpreter.get_input_details()[0]\n","  output_details = interpreter.get_output_details()[0]\n","\n","  # If required, quantize the input layer (from float to integer)\n","  input_scale, input_zero_point = input_details[\"quantization\"]\n","  if (input_scale, input_zero_point) != (0.0, 0):\n","    img_array = np.multiply(img_array, 1.0 / input_scale) + input_zero_point\n","    img_array = img_array.astype(input_details[\"dtype\"])\n","  \n","  # Invoke the interpreter\n","  interpreter.set_tensor(input_details[\"index\"], img_array)\n","  interpreter.invoke()\n","  pred = interpreter.get_tensor(output_details[\"index\"])[0]\n","  \n","  # If required, dequantized the output layer (from integer to float)\n","  output_scale, output_zero_point = output_details[\"quantization\"]\n","  if (output_scale, output_zero_point) != (0.0, 0):\n","    pred = pred.astype(np.float32)\n","    pred = np.multiply((pred - output_zero_point), output_scale)\n","  \n","  predicted_label_index = np.argmax(pred)\n","  predicted_score = pred[predicted_label_index]\n","  return (predicted_label_index, predicted_score)"],"execution_count":27,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"vtee_WxPMgup","executionInfo":{"status":"ok","timestamp":1638748762171,"user_tz":480,"elapsed":137,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"0008362b-c68d-408b-efec-b64136898b4a"},"source":["predict_tflite(model_no_quant_tflite, \"test/7/2.png\")"],"execution_count":28,"outputs":[{"output_type":"execute_result","data":{"text/plain":["(7, 0.9931043)"]},"metadata":{},"execution_count":28}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"0rp0LirfN9vB","executionInfo":{"status":"ok","timestamp":1638748770247,"user_tz":480,"elapsed":165,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"c63b8114-3f8a-45d2-d72b-585a058cb875"},"source":["predict_tflite(model_tflite, \"test/7/2.png\")"],"execution_count":29,"outputs":[{"output_type":"execute_result","data":{"text/plain":["(7, 0.9921875)"]},"metadata":{},"execution_count":29}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":83},"id":"jdNgTO19PRqO","executionInfo":{"status":"ok","timestamp":1638748783929,"user_tz":480,"elapsed":3912,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"8e6c5f8a-9236-4446-ff31-d5f95e170cee"},"source":["from IPython.display import Image, display\n","\n","correct_count = 0\n","wrong_count = 0\n","discarded_count = 0\n","for label_dir in glob.glob(\"test/*\"):\n","  label = int(label_dir.replace(\"test/\", \"\"))\n","  for filename in glob.glob(label_dir + \"/*.png\"):\n","    index, score = predict_tflite(model_tflite, filename)\n","    if score < 0.75:\n","      discarded_count += 1\n","      continue\n","    if index == label:\n","      correct_count += 1\n","    else:\n","      wrong_count += 1\n","      print(\"%d expected, %d found with score %f\" % (label, index, score))\n","      display(Image(filename=filename))\n","\n","correct_percentage = (correct_count / (correct_count + wrong_count)) * 100\n","\n","print(\"%.1f%% correct (N=%d, %d unknown)\" % (correct_percentage, (correct_count + wrong_count), discarded_count))"],"execution_count":30,"outputs":[{"output_type":"stream","name":"stdout","text":["9 expected, 7 found with score 0.816406\n"]},{"output_type":"display_data","data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAA8ElEQVR4nGNgGAWjYBTQHDCSocfoLMMvNoav3AxfeBheixFQzEKS0f4bGN4LMvz6xXDOGCrC+Y3hOxc+LUwkWfCblYHtF8MJS4TILzYCWkiwIH0GA/dXhj2uKIJ/f3MQbwJhkDgPlf+dg+EjH34tpAURzxdU/jshBv5P+LWQnIoq2hmE3jGIv2SIb5di+MXGoPiAVBOIBjfViFFFWhChmP6blUy9RIET5kQqJM4HKrdRuIdsGdh+UdUCtl8MvEip5Rcbg9F5Ii0grqiIWMHA+puhkoGBgYFhgz+Dy0YiTScRTM5hWBpFG6NHwSgYBRQBAJY6MnCXjHpLAAAAAElFTkSuQmCC\n","text/plain":["<IPython.core.display.Image object>"]},"metadata":{}},{"output_type":"stream","name":"stdout","text":["99.9% correct (N=1027, 73 unknown)\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":173},"id":"NTjGMU8BPpoz","executionInfo":{"status":"ok","timestamp":1638748792684,"user_tz":480,"elapsed":135,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"ea56df39-9336-495c-e214-e39f9fcef78e"},"source":["import os\n","import pandas as pd\n","\n","def get_dir_size(dir):\n","  size = 0\n","  for f in os.scandir(dir):\n","    if f.is_file():\n","      size += f.stat().st_size\n","    elif f.is_dir():\n","      size += get_dir_size(f.path)\n","  return size\n","\n","# Calculate size\n","size_tf = get_dir_size(SAVED_MODEL_FILENAME)\n","size_no_quant_tflite = os.path.getsize(FLOAT_TFL_MODEL_FILENAME)\n","size_tflite = os.path.getsize(QUANTIZED_TFL_MODEL_FILENAME)\n","\n","# Compare size\n","pd.DataFrame.from_records(\n","    [[\"TensorFlow\", f\"{size_tf} bytes\", \"\"],\n","     [\"TensorFlow Lite\", f\"{size_no_quant_tflite} bytes \", f\"(reduced by {size_tf - size_no_quant_tflite} bytes)\"],\n","     [\"TensorFlow Lite Quantized\", f\"{size_tflite} bytes\", f\"(reduced by {size_no_quant_tflite - size_tflite} bytes)\"]],\n","     columns = [\"Model\", \"Size\", \"\"], index=\"Model\")\n"],"execution_count":31,"outputs":[{"output_type":"execute_result","data":{"text/html":["<div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>Size</th>\n","      <th></th>\n","    </tr>\n","    <tr>\n","      <th>Model</th>\n","      <th></th>\n","      <th></th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>TensorFlow</th>\n","      <td>668171 bytes</td>\n","      <td></td>\n","    </tr>\n","    <tr>\n","      <th>TensorFlow Lite</th>\n","      <td>100096 bytes</td>\n","      <td>(reduced by 568075 bytes)</td>\n","    </tr>\n","    <tr>\n","      <th>TensorFlow Lite Quantized</th>\n","      <td>30880 bytes</td>\n","      <td>(reduced by 69216 bytes)</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>"],"text/plain":["                                    Size                           \n","Model                                                              \n","TensorFlow                  668171 bytes                           \n","TensorFlow Lite            100096 bytes   (reduced by 568075 bytes)\n","TensorFlow Lite Quantized    30880 bytes   (reduced by 69216 bytes)"]},"metadata":{},"execution_count":31}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"mrvnEJLfR8KU","executionInfo":{"status":"ok","timestamp":1638748913062,"user_tz":480,"elapsed":12258,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"fa3461ec-a27f-45c5-f6d0-555d339415cf"},"source":["# Install xxd if it is not available\n","!apt-get update && apt-get -qq install xxd\n","# Convert to a C source file, i.e, a TensorFlow Lite for Microcontrollers model\n","!xxd -i {QUANTIZED_TFL_MODEL_FILENAME} > {TFL_CC_MODEL_FILENAME}\n","# Update variable names\n","REPLACE_TEXT = QUANTIZED_TFL_MODEL_FILENAME.replace('/', '_').replace('.', '_')\n","!sed -i 's/'{REPLACE_TEXT}'/g_magic_wand_model_data/g' {TFL_CC_MODEL_FILENAME}"],"execution_count":32,"outputs":[{"output_type":"stream","name":"stdout","text":["\r0% [Working]\r            \rGet:1 http://security.ubuntu.com/ubuntu bionic-security InRelease [88.7 kB]\n","Ign:2 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  InRelease\n","Get:3 https://cloud.r-project.org/bin/linux/ubuntu bionic-cran40/ InRelease [3,626 B]\n","Ign:4 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  InRelease\n","Hit:5 http://archive.ubuntu.com/ubuntu bionic InRelease\n","Get:6 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Release [696 B]\n","Hit:7 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  Release\n","Get:8 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Release.gpg [836 B]\n","Get:9 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic InRelease [15.9 kB]\n","Get:10 http://archive.ubuntu.com/ubuntu bionic-updates InRelease [88.7 kB]\n","Get:11 http://security.ubuntu.com/ubuntu bionic-security/universe amd64 Packages [1,444 kB]\n","Hit:12 http://ppa.launchpad.net/cran/libgit2/ubuntu bionic InRelease\n","Get:13 http://security.ubuntu.com/ubuntu bionic-security/main amd64 Packages [2,461 kB]\n","Get:14 http://archive.ubuntu.com/ubuntu bionic-backports InRelease [74.6 kB]\n","Get:15 http://security.ubuntu.com/ubuntu bionic-security/restricted amd64 Packages [691 kB]\n","Hit:16 http://ppa.launchpad.net/deadsnakes/ppa/ubuntu bionic InRelease\n","Get:17 http://ppa.launchpad.net/graphics-drivers/ppa/ubuntu bionic InRelease [21.3 kB]\n","Get:19 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Packages [829 kB]\n","Get:20 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic/main Sources [1,814 kB]\n","Get:21 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 Packages [2,898 kB]\n","Get:22 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic/main amd64 Packages [931 kB]\n","Get:23 http://archive.ubuntu.com/ubuntu bionic-updates/restricted amd64 Packages [725 kB]\n","Get:24 http://archive.ubuntu.com/ubuntu bionic-updates/universe amd64 Packages [2,225 kB]\n","Get:25 http://ppa.launchpad.net/graphics-drivers/ppa/ubuntu bionic/main amd64 Packages [44.7 kB]\n","Fetched 14.4 MB in 4s (3,767 kB/s)\n","Reading package lists... Done\n","Selecting previously unselected package xxd.\n","(Reading database ... 155222 files and directories currently installed.)\n","Preparing to unpack .../xxd_2%3a8.0.1453-1ubuntu1.7_amd64.deb ...\n","Unpacking xxd (2:8.0.1453-1ubuntu1.7) ...\n","Setting up xxd (2:8.0.1453-1ubuntu1.7) ...\n","Processing triggers for man-db (2.8.3-2ubuntu0.1) ...\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"oazLUtBqWzdJ","executionInfo":{"status":"ok","timestamp":1638748916580,"user_tz":480,"elapsed":339,"user":{"displayName":"David Davis","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"03716636181783186066"}},"outputId":"b6b57fbb-02e9-4972-8bb2-bedc856f0eaa"},"source":["# Print the C source file\n","!tail {TFL_CC_MODEL_FILENAME}"],"execution_count":33,"outputs":[{"output_type":"stream","name":"stdout","text":["  0x75, 0x6c, 0x74, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x31, 0x3a,\n","  0x30, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,\n","  0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,\n","  0x0c, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x08, 0x00,\n","  0x0c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,\n","  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x01, 0x00, 0x00, 0x00,\n","  0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x04, 0x00, 0x04, 0x00,\n","  0x04, 0x00, 0x00, 0x00\n","};\n","unsigned int g_magic_wand_model_data_len = 30880;\n"]}]},{"cell_type":"code","metadata":{"id":"VqN2F42PW-uv"},"source":[""],"execution_count":null,"outputs":[]}]}